// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.sell.order.detail;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.SellOrderDetail;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(SellOrderDetail.class)
@Setter
@Getter
public class SellOrderDetailSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "SellOrderDetail".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("parentId", "so");
    map.put("productId", "p");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 所属销售订单
   */
  private Long parentId;

  /**
   * 所属销售订单 比较(eq)
   */
  private Long parentIdEq;
  /**
   * 所属销售订单 比较(neq)
   */
  private Long parentIdNeq;
  /**
   * 所属销售订单 比较(gt)
   */
  private Long parentIdGt;
  /**
   * 所属销售订单 比较(gte)
   */
  private Long parentIdGte;
  /**
   * 所属销售订单 比较(lt)
   */
  private Long parentIdLt;
  /**
   * 所属销售订单 比较(lte)
   */
  private Long parentIdLte;
  /**
   * 所属销售订单 比较(contains)
   */
  private Long parentIdContains;
  /**
   * 所属销售订单 比较(notcontains)
   */
  private Long parentIdNotcontains;
  /**
   * 所属销售订单 比较(startswith)
   */
  private Long parentIdStartswith;
  /**
   * 所属销售订单 比较(endswith)
   */
  private Long parentIdEndswith;
  /**
   * 所属销售订单 比较(isnull)
   */
  private Boolean parentIdIsnull;
  /**
   * 所属销售订单 比较(isnotnull)
   */
  private Boolean parentIdIsnotnull;
  /**
   * 所属销售订单的订单号 比较(eq)
   */
  private String parentIdAmazonOrderIdEq;
  /**
   * 所属销售订单的订单号 比较(neq)
   */
  private String parentIdAmazonOrderIdNeq;
  /**
   * 所属销售订单的订单号 比较(gt)
   */
  private String parentIdAmazonOrderIdGt;
  /**
   * 所属销售订单的订单号 比较(gte)
   */
  private String parentIdAmazonOrderIdGte;
  /**
   * 所属销售订单的订单号 比较(lt)
   */
  private String parentIdAmazonOrderIdLt;
  /**
   * 所属销售订单的订单号 比较(lte)
   */
  private String parentIdAmazonOrderIdLte;
  /**
   * 所属销售订单的订单号 比较(contains)
   */
  private String parentIdAmazonOrderIdContains;
  /**
   * 所属销售订单的订单号 比较(notcontains)
   */
  private String parentIdAmazonOrderIdNotcontains;
  /**
   * 所属销售订单的订单号 比较(startswith)
   */
  private String parentIdAmazonOrderIdStartswith;
  /**
   * 所属销售订单的订单号 比较(endswith)
   */
  private String parentIdAmazonOrderIdEndswith;
  /**
   * 所属销售订单的订单号 比较(isnull)
   */
  private Boolean parentIdAmazonOrderIdIsnull;
  /**
   * 所属销售订单的订单号 比较(isnotnull)
   */
  private Boolean parentIdAmazonOrderIdIsnotnull;

  /**
   * 所属销售订单(范围搜索)
   */
  private List<Long> parentIdInList;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 是否有 图片
   */
  private Boolean img;

  /**
   * 标题(模糊搜索)
   */
  private String title;

  /**
   * 标题 比较(eq)
   */
  private String titleEq;
  /**
   * 标题 比较(neq)
   */
  private String titleNeq;
  /**
   * 标题 比较(gt)
   */
  private String titleGt;
  /**
   * 标题 比较(gte)
   */
  private String titleGte;
  /**
   * 标题 比较(lt)
   */
  private String titleLt;
  /**
   * 标题 比较(lte)
   */
  private String titleLte;
  /**
   * 标题 比较(contains)
   */
  private String titleContains;
  /**
   * 标题 比较(notcontains)
   */
  private String titleNotcontains;
  /**
   * 标题 比较(startswith)
   */
  private String titleStartswith;
  /**
   * 标题 比较(endswith)
   */
  private String titleEndswith;
  /**
   * 标题 比较(isnull)
   */
  private Boolean titleIsnull;
  /**
   * 标题 比较(isnotnull)
   */
  private Boolean titleIsnotnull;

  /**
   * 标题(精确搜索)
   */
  private List<String> titleInList;

  /**
   * ASIN(模糊搜索)
   */
  private String asin;

  /**
   * ASIN 比较(eq)
   */
  private String asinEq;
  /**
   * ASIN 比较(neq)
   */
  private String asinNeq;
  /**
   * ASIN 比较(gt)
   */
  private String asinGt;
  /**
   * ASIN 比较(gte)
   */
  private String asinGte;
  /**
   * ASIN 比较(lt)
   */
  private String asinLt;
  /**
   * ASIN 比较(lte)
   */
  private String asinLte;
  /**
   * ASIN 比较(contains)
   */
  private String asinContains;
  /**
   * ASIN 比较(notcontains)
   */
  private String asinNotcontains;
  /**
   * ASIN 比较(startswith)
   */
  private String asinStartswith;
  /**
   * ASIN 比较(endswith)
   */
  private String asinEndswith;
  /**
   * ASIN 比较(isnull)
   */
  private Boolean asinIsnull;
  /**
   * ASIN 比较(isnotnull)
   */
  private Boolean asinIsnotnull;

  /**
   * ASIN(精确搜索)
   */
  private List<String> asinInList;

  /**
   * asin链接(模糊搜索)
   */
  private String asinUrl;

  /**
   * asin链接 比较(eq)
   */
  private String asinUrlEq;
  /**
   * asin链接 比较(neq)
   */
  private String asinUrlNeq;
  /**
   * asin链接 比较(gt)
   */
  private String asinUrlGt;
  /**
   * asin链接 比较(gte)
   */
  private String asinUrlGte;
  /**
   * asin链接 比较(lt)
   */
  private String asinUrlLt;
  /**
   * asin链接 比较(lte)
   */
  private String asinUrlLte;
  /**
   * asin链接 比较(contains)
   */
  private String asinUrlContains;
  /**
   * asin链接 比较(notcontains)
   */
  private String asinUrlNotcontains;
  /**
   * asin链接 比较(startswith)
   */
  private String asinUrlStartswith;
  /**
   * asin链接 比较(endswith)
   */
  private String asinUrlEndswith;
  /**
   * asin链接 比较(isnull)
   */
  private Boolean asinUrlIsnull;
  /**
   * asin链接 比较(isnotnull)
   */
  private Boolean asinUrlIsnotnull;

  /**
   * asin链接(精确搜索)
   */
  private List<String> asinUrlInList;

  /**
   * MSKU(模糊搜索)
   */
  private String sellerSku;

  /**
   * MSKU 比较(eq)
   */
  private String sellerSkuEq;
  /**
   * MSKU 比较(neq)
   */
  private String sellerSkuNeq;
  /**
   * MSKU 比较(gt)
   */
  private String sellerSkuGt;
  /**
   * MSKU 比较(gte)
   */
  private String sellerSkuGte;
  /**
   * MSKU 比较(lt)
   */
  private String sellerSkuLt;
  /**
   * MSKU 比较(lte)
   */
  private String sellerSkuLte;
  /**
   * MSKU 比较(contains)
   */
  private String sellerSkuContains;
  /**
   * MSKU 比较(notcontains)
   */
  private String sellerSkuNotcontains;
  /**
   * MSKU 比较(startswith)
   */
  private String sellerSkuStartswith;
  /**
   * MSKU 比较(endswith)
   */
  private String sellerSkuEndswith;
  /**
   * MSKU 比较(isnull)
   */
  private Boolean sellerSkuIsnull;
  /**
   * MSKU 比较(isnotnull)
   */
  private Boolean sellerSkuIsnotnull;

  /**
   * MSKU(精确搜索)
   */
  private List<String> sellerSkuInList;

  /**
   * 商品编码(模糊搜索)
   */
  private String orderItemId;

  /**
   * 商品编码 比较(eq)
   */
  private String orderItemIdEq;
  /**
   * 商品编码 比较(neq)
   */
  private String orderItemIdNeq;
  /**
   * 商品编码 比较(gt)
   */
  private String orderItemIdGt;
  /**
   * 商品编码 比较(gte)
   */
  private String orderItemIdGte;
  /**
   * 商品编码 比较(lt)
   */
  private String orderItemIdLt;
  /**
   * 商品编码 比较(lte)
   */
  private String orderItemIdLte;
  /**
   * 商品编码 比较(contains)
   */
  private String orderItemIdContains;
  /**
   * 商品编码 比较(notcontains)
   */
  private String orderItemIdNotcontains;
  /**
   * 商品编码 比较(startswith)
   */
  private String orderItemIdStartswith;
  /**
   * 商品编码 比较(endswith)
   */
  private String orderItemIdEndswith;
  /**
   * 商品编码 比较(isnull)
   */
  private Boolean orderItemIdIsnull;
  /**
   * 商品编码 比较(isnotnull)
   */
  private Boolean orderItemIdIsnotnull;

  /**
   * 商品编码(精确搜索)
   */
  private List<String> orderItemIdInList;

  /**
   * 品名(模糊搜索)
   */
  private String productName;

  /**
   * 品名 比较(eq)
   */
  private String productNameEq;
  /**
   * 品名 比较(neq)
   */
  private String productNameNeq;
  /**
   * 品名 比较(gt)
   */
  private String productNameGt;
  /**
   * 品名 比较(gte)
   */
  private String productNameGte;
  /**
   * 品名 比较(lt)
   */
  private String productNameLt;
  /**
   * 品名 比较(lte)
   */
  private String productNameLte;
  /**
   * 品名 比较(contains)
   */
  private String productNameContains;
  /**
   * 品名 比较(notcontains)
   */
  private String productNameNotcontains;
  /**
   * 品名 比较(startswith)
   */
  private String productNameStartswith;
  /**
   * 品名 比较(endswith)
   */
  private String productNameEndswith;
  /**
   * 品名 比较(isnull)
   */
  private Boolean productNameIsnull;
  /**
   * 品名 比较(isnotnull)
   */
  private Boolean productNameIsnotnull;

  /**
   * 品名(精确搜索)
   */
  private List<String> productNameInList;

  /**
   * 本地产品
   */
  private Long productId;

  /**
   * 本地产品 比较(eq)
   */
  private Long productIdEq;
  /**
   * 本地产品 比较(neq)
   */
  private Long productIdNeq;
  /**
   * 本地产品 比较(gt)
   */
  private Long productIdGt;
  /**
   * 本地产品 比较(gte)
   */
  private Long productIdGte;
  /**
   * 本地产品 比较(lt)
   */
  private Long productIdLt;
  /**
   * 本地产品 比较(lte)
   */
  private Long productIdLte;
  /**
   * 本地产品 比较(contains)
   */
  private Long productIdContains;
  /**
   * 本地产品 比较(notcontains)
   */
  private Long productIdNotcontains;
  /**
   * 本地产品 比较(startswith)
   */
  private Long productIdStartswith;
  /**
   * 本地产品 比较(endswith)
   */
  private Long productIdEndswith;
  /**
   * 本地产品 比较(isnull)
   */
  private Boolean productIdIsnull;
  /**
   * 本地产品 比较(isnotnull)
   */
  private Boolean productIdIsnotnull;
  /**
   * 本地产品的品名 比较(eq)
   */
  private String productIdNameEq;
  /**
   * 本地产品的品名 比较(neq)
   */
  private String productIdNameNeq;
  /**
   * 本地产品的品名 比较(gt)
   */
  private String productIdNameGt;
  /**
   * 本地产品的品名 比较(gte)
   */
  private String productIdNameGte;
  /**
   * 本地产品的品名 比较(lt)
   */
  private String productIdNameLt;
  /**
   * 本地产品的品名 比较(lte)
   */
  private String productIdNameLte;
  /**
   * 本地产品的品名 比较(contains)
   */
  private String productIdNameContains;
  /**
   * 本地产品的品名 比较(notcontains)
   */
  private String productIdNameNotcontains;
  /**
   * 本地产品的品名 比较(startswith)
   */
  private String productIdNameStartswith;
  /**
   * 本地产品的品名 比较(endswith)
   */
  private String productIdNameEndswith;
  /**
   * 本地产品的品名 比较(isnull)
   */
  private Boolean productIdNameIsnull;
  /**
   * 本地产品的品名 比较(isnotnull)
   */
  private Boolean productIdNameIsnotnull;

  /**
   * 本地产品(范围搜索)
   */
  private List<Long> productIdInList;

  /**
   * SKU(模糊搜索)
   */
  private String sku;

  /**
   * SKU 比较(eq)
   */
  private String skuEq;
  /**
   * SKU 比较(neq)
   */
  private String skuNeq;
  /**
   * SKU 比较(gt)
   */
  private String skuGt;
  /**
   * SKU 比较(gte)
   */
  private String skuGte;
  /**
   * SKU 比较(lt)
   */
  private String skuLt;
  /**
   * SKU 比较(lte)
   */
  private String skuLte;
  /**
   * SKU 比较(contains)
   */
  private String skuContains;
  /**
   * SKU 比较(notcontains)
   */
  private String skuNotcontains;
  /**
   * SKU 比较(startswith)
   */
  private String skuStartswith;
  /**
   * SKU 比较(endswith)
   */
  private String skuEndswith;
  /**
   * SKU 比较(isnull)
   */
  private Boolean skuIsnull;
  /**
   * SKU 比较(isnotnull)
   */
  private Boolean skuIsnotnull;

  /**
   * SKU(精确搜索)
   */
  private List<String> skuInList;

  /**
   * 单价
   */
  private java.math.BigDecimal unitPriceAmount;

  /**
   * 最小单价
   */
  private java.math.BigDecimal unitPriceAmountMin;

  /**
   * 最大单价
   */
  private java.math.BigDecimal unitPriceAmountMax;

  /**
   * 单价 比较(eq)
   */
  private java.math.BigDecimal unitPriceAmountEq;
  /**
   * 单价 比较(neq)
   */
  private java.math.BigDecimal unitPriceAmountNeq;
  /**
   * 单价 比较(gt)
   */
  private java.math.BigDecimal unitPriceAmountGt;
  /**
   * 单价 比较(gte)
   */
  private java.math.BigDecimal unitPriceAmountGte;
  /**
   * 单价 比较(lt)
   */
  private java.math.BigDecimal unitPriceAmountLt;
  /**
   * 单价 比较(lte)
   */
  private java.math.BigDecimal unitPriceAmountLte;
  /**
   * 单价 比较(contains)
   */
  private java.math.BigDecimal unitPriceAmountContains;
  /**
   * 单价 比较(notcontains)
   */
  private java.math.BigDecimal unitPriceAmountNotcontains;
  /**
   * 单价 比较(startswith)
   */
  private java.math.BigDecimal unitPriceAmountStartswith;
  /**
   * 单价 比较(endswith)
   */
  private java.math.BigDecimal unitPriceAmountEndswith;
  /**
   * 单价 比较(isnull)
   */
  private Boolean unitPriceAmountIsnull;
  /**
   * 单价 比较(isnotnull)
   */
  private Boolean unitPriceAmountIsnotnull;

  /**
   * 数量
   */
  private Integer quantityOrdered;

  /**
   * 最小数量
   */
  private Integer quantityOrderedMin;

  /**
   * 最大数量
   */
  private Integer quantityOrderedMax;

  /**
   * 数量 比较(eq)
   */
  private Integer quantityOrderedEq;
  /**
   * 数量 比较(neq)
   */
  private Integer quantityOrderedNeq;
  /**
   * 数量 比较(gt)
   */
  private Integer quantityOrderedGt;
  /**
   * 数量 比较(gte)
   */
  private Integer quantityOrderedGte;
  /**
   * 数量 比较(lt)
   */
  private Integer quantityOrderedLt;
  /**
   * 数量 比较(lte)
   */
  private Integer quantityOrderedLte;
  /**
   * 数量 比较(contains)
   */
  private Integer quantityOrderedContains;
  /**
   * 数量 比较(notcontains)
   */
  private Integer quantityOrderedNotcontains;
  /**
   * 数量 比较(startswith)
   */
  private Integer quantityOrderedStartswith;
  /**
   * 数量 比较(endswith)
   */
  private Integer quantityOrderedEndswith;
  /**
   * 数量 比较(isnull)
   */
  private Boolean quantityOrderedIsnull;
  /**
   * 数量 比较(isnotnull)
   */
  private Boolean quantityOrderedIsnotnull;

  /**
   * 已配送
   */
  private Integer quantityShipped;

  /**
   * 最小已配送
   */
  private Integer quantityShippedMin;

  /**
   * 最大已配送
   */
  private Integer quantityShippedMax;

  /**
   * 已配送 比较(eq)
   */
  private Integer quantityShippedEq;
  /**
   * 已配送 比较(neq)
   */
  private Integer quantityShippedNeq;
  /**
   * 已配送 比较(gt)
   */
  private Integer quantityShippedGt;
  /**
   * 已配送 比较(gte)
   */
  private Integer quantityShippedGte;
  /**
   * 已配送 比较(lt)
   */
  private Integer quantityShippedLt;
  /**
   * 已配送 比较(lte)
   */
  private Integer quantityShippedLte;
  /**
   * 已配送 比较(contains)
   */
  private Integer quantityShippedContains;
  /**
   * 已配送 比较(notcontains)
   */
  private Integer quantityShippedNotcontains;
  /**
   * 已配送 比较(startswith)
   */
  private Integer quantityShippedStartswith;
  /**
   * 已配送 比较(endswith)
   */
  private Integer quantityShippedEndswith;
  /**
   * 已配送 比较(isnull)
   */
  private Boolean quantityShippedIsnull;
  /**
   * 已配送 比较(isnotnull)
   */
  private Boolean quantityShippedIsnotnull;

  /**
   * 销售收益
   */
  private java.math.BigDecimal salesPriceAmount;

  /**
   * 最小销售收益
   */
  private java.math.BigDecimal salesPriceAmountMin;

  /**
   * 最大销售收益
   */
  private java.math.BigDecimal salesPriceAmountMax;

  /**
   * 销售收益 比较(eq)
   */
  private java.math.BigDecimal salesPriceAmountEq;
  /**
   * 销售收益 比较(neq)
   */
  private java.math.BigDecimal salesPriceAmountNeq;
  /**
   * 销售收益 比较(gt)
   */
  private java.math.BigDecimal salesPriceAmountGt;
  /**
   * 销售收益 比较(gte)
   */
  private java.math.BigDecimal salesPriceAmountGte;
  /**
   * 销售收益 比较(lt)
   */
  private java.math.BigDecimal salesPriceAmountLt;
  /**
   * 销售收益 比较(lte)
   */
  private java.math.BigDecimal salesPriceAmountLte;
  /**
   * 销售收益 比较(contains)
   */
  private java.math.BigDecimal salesPriceAmountContains;
  /**
   * 销售收益 比较(notcontains)
   */
  private java.math.BigDecimal salesPriceAmountNotcontains;
  /**
   * 销售收益 比较(startswith)
   */
  private java.math.BigDecimal salesPriceAmountStartswith;
  /**
   * 销售收益 比较(endswith)
   */
  private java.math.BigDecimal salesPriceAmountEndswith;
  /**
   * 销售收益 比较(isnull)
   */
  private Boolean salesPriceAmountIsnull;
  /**
   * 销售收益 比较(isnotnull)
   */
  private Boolean salesPriceAmountIsnotnull;

  /**
   * 积分成本
   */
  private java.math.BigDecimal pointsMonetaryValueAmount;

  /**
   * 最小积分成本
   */
  private java.math.BigDecimal pointsMonetaryValueAmountMin;

  /**
   * 最大积分成本
   */
  private java.math.BigDecimal pointsMonetaryValueAmountMax;

  /**
   * 积分成本 比较(eq)
   */
  private java.math.BigDecimal pointsMonetaryValueAmountEq;
  /**
   * 积分成本 比较(neq)
   */
  private java.math.BigDecimal pointsMonetaryValueAmountNeq;
  /**
   * 积分成本 比较(gt)
   */
  private java.math.BigDecimal pointsMonetaryValueAmountGt;
  /**
   * 积分成本 比较(gte)
   */
  private java.math.BigDecimal pointsMonetaryValueAmountGte;
  /**
   * 积分成本 比较(lt)
   */
  private java.math.BigDecimal pointsMonetaryValueAmountLt;
  /**
   * 积分成本 比较(lte)
   */
  private java.math.BigDecimal pointsMonetaryValueAmountLte;
  /**
   * 积分成本 比较(contains)
   */
  private java.math.BigDecimal pointsMonetaryValueAmountContains;
  /**
   * 积分成本 比较(notcontains)
   */
  private java.math.BigDecimal pointsMonetaryValueAmountNotcontains;
  /**
   * 积分成本 比较(startswith)
   */
  private java.math.BigDecimal pointsMonetaryValueAmountStartswith;
  /**
   * 积分成本 比较(endswith)
   */
  private java.math.BigDecimal pointsMonetaryValueAmountEndswith;
  /**
   * 积分成本 比较(isnull)
   */
  private Boolean pointsMonetaryValueAmountIsnull;
  /**
   * 积分成本 比较(isnotnull)
   */
  private Boolean pointsMonetaryValueAmountIsnotnull;

  /**
   * 税费
   */
  private java.math.BigDecimal taxAmount;

  /**
   * 最小税费
   */
  private java.math.BigDecimal taxAmountMin;

  /**
   * 最大税费
   */
  private java.math.BigDecimal taxAmountMax;

  /**
   * 税费 比较(eq)
   */
  private java.math.BigDecimal taxAmountEq;
  /**
   * 税费 比较(neq)
   */
  private java.math.BigDecimal taxAmountNeq;
  /**
   * 税费 比较(gt)
   */
  private java.math.BigDecimal taxAmountGt;
  /**
   * 税费 比较(gte)
   */
  private java.math.BigDecimal taxAmountGte;
  /**
   * 税费 比较(lt)
   */
  private java.math.BigDecimal taxAmountLt;
  /**
   * 税费 比较(lte)
   */
  private java.math.BigDecimal taxAmountLte;
  /**
   * 税费 比较(contains)
   */
  private java.math.BigDecimal taxAmountContains;
  /**
   * 税费 比较(notcontains)
   */
  private java.math.BigDecimal taxAmountNotcontains;
  /**
   * 税费 比较(startswith)
   */
  private java.math.BigDecimal taxAmountStartswith;
  /**
   * 税费 比较(endswith)
   */
  private java.math.BigDecimal taxAmountEndswith;
  /**
   * 税费 比较(isnull)
   */
  private Boolean taxAmountIsnull;
  /**
   * 税费 比较(isnotnull)
   */
  private Boolean taxAmountIsnotnull;

  /**
   * 采购成本
   */
  private java.math.BigDecimal cgPrice;

  /**
   * 最小采购成本
   */
  private java.math.BigDecimal cgPriceMin;

  /**
   * 最大采购成本
   */
  private java.math.BigDecimal cgPriceMax;

  /**
   * 采购成本 比较(eq)
   */
  private java.math.BigDecimal cgPriceEq;
  /**
   * 采购成本 比较(neq)
   */
  private java.math.BigDecimal cgPriceNeq;
  /**
   * 采购成本 比较(gt)
   */
  private java.math.BigDecimal cgPriceGt;
  /**
   * 采购成本 比较(gte)
   */
  private java.math.BigDecimal cgPriceGte;
  /**
   * 采购成本 比较(lt)
   */
  private java.math.BigDecimal cgPriceLt;
  /**
   * 采购成本 比较(lte)
   */
  private java.math.BigDecimal cgPriceLte;
  /**
   * 采购成本 比较(contains)
   */
  private java.math.BigDecimal cgPriceContains;
  /**
   * 采购成本 比较(notcontains)
   */
  private java.math.BigDecimal cgPriceNotcontains;
  /**
   * 采购成本 比较(startswith)
   */
  private java.math.BigDecimal cgPriceStartswith;
  /**
   * 采购成本 比较(endswith)
   */
  private java.math.BigDecimal cgPriceEndswith;
  /**
   * 采购成本 比较(isnull)
   */
  private Boolean cgPriceIsnull;
  /**
   * 采购成本 比较(isnotnull)
   */
  private Boolean cgPriceIsnotnull;

  /**
   * 头程费用
   */
  private java.math.BigDecimal cgTransportCosts;

  /**
   * 最小头程费用
   */
  private java.math.BigDecimal cgTransportCostsMin;

  /**
   * 最大头程费用
   */
  private java.math.BigDecimal cgTransportCostsMax;

  /**
   * 头程费用 比较(eq)
   */
  private java.math.BigDecimal cgTransportCostsEq;
  /**
   * 头程费用 比较(neq)
   */
  private java.math.BigDecimal cgTransportCostsNeq;
  /**
   * 头程费用 比较(gt)
   */
  private java.math.BigDecimal cgTransportCostsGt;
  /**
   * 头程费用 比较(gte)
   */
  private java.math.BigDecimal cgTransportCostsGte;
  /**
   * 头程费用 比较(lt)
   */
  private java.math.BigDecimal cgTransportCostsLt;
  /**
   * 头程费用 比较(lte)
   */
  private java.math.BigDecimal cgTransportCostsLte;
  /**
   * 头程费用 比较(contains)
   */
  private java.math.BigDecimal cgTransportCostsContains;
  /**
   * 头程费用 比较(notcontains)
   */
  private java.math.BigDecimal cgTransportCostsNotcontains;
  /**
   * 头程费用 比较(startswith)
   */
  private java.math.BigDecimal cgTransportCostsStartswith;
  /**
   * 头程费用 比较(endswith)
   */
  private java.math.BigDecimal cgTransportCostsEndswith;
  /**
   * 头程费用 比较(isnull)
   */
  private Boolean cgTransportCostsIsnull;
  /**
   * 头程费用 比较(isnotnull)
   */
  private Boolean cgTransportCostsIsnotnull;

  /**
   * FBA发货费
   */
  private java.math.BigDecimal fbaShipmentAmount;

  /**
   * 最小FBA发货费
   */
  private java.math.BigDecimal fbaShipmentAmountMin;

  /**
   * 最大FBA发货费
   */
  private java.math.BigDecimal fbaShipmentAmountMax;

  /**
   * FBA发货费 比较(eq)
   */
  private java.math.BigDecimal fbaShipmentAmountEq;
  /**
   * FBA发货费 比较(neq)
   */
  private java.math.BigDecimal fbaShipmentAmountNeq;
  /**
   * FBA发货费 比较(gt)
   */
  private java.math.BigDecimal fbaShipmentAmountGt;
  /**
   * FBA发货费 比较(gte)
   */
  private java.math.BigDecimal fbaShipmentAmountGte;
  /**
   * FBA发货费 比较(lt)
   */
  private java.math.BigDecimal fbaShipmentAmountLt;
  /**
   * FBA发货费 比较(lte)
   */
  private java.math.BigDecimal fbaShipmentAmountLte;
  /**
   * FBA发货费 比较(contains)
   */
  private java.math.BigDecimal fbaShipmentAmountContains;
  /**
   * FBA发货费 比较(notcontains)
   */
  private java.math.BigDecimal fbaShipmentAmountNotcontains;
  /**
   * FBA发货费 比较(startswith)
   */
  private java.math.BigDecimal fbaShipmentAmountStartswith;
  /**
   * FBA发货费 比较(endswith)
   */
  private java.math.BigDecimal fbaShipmentAmountEndswith;
  /**
   * FBA发货费 比较(isnull)
   */
  private Boolean fbaShipmentAmountIsnull;
  /**
   * FBA发货费 比较(isnotnull)
   */
  private Boolean fbaShipmentAmountIsnotnull;

  /**
   * 促销费
   */
  private java.math.BigDecimal promotionAmount;

  /**
   * 最小促销费
   */
  private java.math.BigDecimal promotionAmountMin;

  /**
   * 最大促销费
   */
  private java.math.BigDecimal promotionAmountMax;

  /**
   * 促销费 比较(eq)
   */
  private java.math.BigDecimal promotionAmountEq;
  /**
   * 促销费 比较(neq)
   */
  private java.math.BigDecimal promotionAmountNeq;
  /**
   * 促销费 比较(gt)
   */
  private java.math.BigDecimal promotionAmountGt;
  /**
   * 促销费 比较(gte)
   */
  private java.math.BigDecimal promotionAmountGte;
  /**
   * 促销费 比较(lt)
   */
  private java.math.BigDecimal promotionAmountLt;
  /**
   * 促销费 比较(lte)
   */
  private java.math.BigDecimal promotionAmountLte;
  /**
   * 促销费 比较(contains)
   */
  private java.math.BigDecimal promotionAmountContains;
  /**
   * 促销费 比较(notcontains)
   */
  private java.math.BigDecimal promotionAmountNotcontains;
  /**
   * 促销费 比较(startswith)
   */
  private java.math.BigDecimal promotionAmountStartswith;
  /**
   * 促销费 比较(endswith)
   */
  private java.math.BigDecimal promotionAmountEndswith;
  /**
   * 促销费 比较(isnull)
   */
  private Boolean promotionAmountIsnull;
  /**
   * 促销费 比较(isnotnull)
   */
  private Boolean promotionAmountIsnotnull;

  /**
   * 商品促销编号(模糊搜索)
   */
  private String promotionIds;

  /**
   * 商品促销编号 比较(eq)
   */
  private String promotionIdsEq;
  /**
   * 商品促销编号 比较(neq)
   */
  private String promotionIdsNeq;
  /**
   * 商品促销编号 比较(gt)
   */
  private String promotionIdsGt;
  /**
   * 商品促销编号 比较(gte)
   */
  private String promotionIdsGte;
  /**
   * 商品促销编号 比较(lt)
   */
  private String promotionIdsLt;
  /**
   * 商品促销编号 比较(lte)
   */
  private String promotionIdsLte;
  /**
   * 商品促销编号 比较(contains)
   */
  private String promotionIdsContains;
  /**
   * 商品促销编号 比较(notcontains)
   */
  private String promotionIdsNotcontains;
  /**
   * 商品促销编号 比较(startswith)
   */
  private String promotionIdsStartswith;
  /**
   * 商品促销编号 比较(endswith)
   */
  private String promotionIdsEndswith;
  /**
   * 商品促销编号 比较(isnull)
   */
  private Boolean promotionIdsIsnull;
  /**
   * 商品促销编号 比较(isnotnull)
   */
  private Boolean promotionIdsIsnotnull;

  /**
   * 商品促销编号(精确搜索)
   */
  private List<String> promotionIdsInList;

  /**
   * 平台费
   */
  private java.math.BigDecimal commissionAmount;

  /**
   * 最小平台费
   */
  private java.math.BigDecimal commissionAmountMin;

  /**
   * 最大平台费
   */
  private java.math.BigDecimal commissionAmountMax;

  /**
   * 平台费 比较(eq)
   */
  private java.math.BigDecimal commissionAmountEq;
  /**
   * 平台费 比较(neq)
   */
  private java.math.BigDecimal commissionAmountNeq;
  /**
   * 平台费 比较(gt)
   */
  private java.math.BigDecimal commissionAmountGt;
  /**
   * 平台费 比较(gte)
   */
  private java.math.BigDecimal commissionAmountGte;
  /**
   * 平台费 比较(lt)
   */
  private java.math.BigDecimal commissionAmountLt;
  /**
   * 平台费 比较(lte)
   */
  private java.math.BigDecimal commissionAmountLte;
  /**
   * 平台费 比较(contains)
   */
  private java.math.BigDecimal commissionAmountContains;
  /**
   * 平台费 比较(notcontains)
   */
  private java.math.BigDecimal commissionAmountNotcontains;
  /**
   * 平台费 比较(startswith)
   */
  private java.math.BigDecimal commissionAmountStartswith;
  /**
   * 平台费 比较(endswith)
   */
  private java.math.BigDecimal commissionAmountEndswith;
  /**
   * 平台费 比较(isnull)
   */
  private Boolean commissionAmountIsnull;
  /**
   * 平台费 比较(isnotnull)
   */
  private Boolean commissionAmountIsnotnull;

  /**
   * 其他费
   */
  private java.math.BigDecimal feeCostAmount;

  /**
   * 最小其他费
   */
  private java.math.BigDecimal feeCostAmountMin;

  /**
   * 最大其他费
   */
  private java.math.BigDecimal feeCostAmountMax;

  /**
   * 其他费 比较(eq)
   */
  private java.math.BigDecimal feeCostAmountEq;
  /**
   * 其他费 比较(neq)
   */
  private java.math.BigDecimal feeCostAmountNeq;
  /**
   * 其他费 比较(gt)
   */
  private java.math.BigDecimal feeCostAmountGt;
  /**
   * 其他费 比较(gte)
   */
  private java.math.BigDecimal feeCostAmountGte;
  /**
   * 其他费 比较(lt)
   */
  private java.math.BigDecimal feeCostAmountLt;
  /**
   * 其他费 比较(lte)
   */
  private java.math.BigDecimal feeCostAmountLte;
  /**
   * 其他费 比较(contains)
   */
  private java.math.BigDecimal feeCostAmountContains;
  /**
   * 其他费 比较(notcontains)
   */
  private java.math.BigDecimal feeCostAmountNotcontains;
  /**
   * 其他费 比较(startswith)
   */
  private java.math.BigDecimal feeCostAmountStartswith;
  /**
   * 其他费 比较(endswith)
   */
  private java.math.BigDecimal feeCostAmountEndswith;
  /**
   * 其他费 比较(isnull)
   */
  private Boolean feeCostAmountIsnull;
  /**
   * 其他费 比较(isnotnull)
   */
  private Boolean feeCostAmountIsnotnull;

  /**
   * 其他费用
   */
  private java.math.BigDecimal otherAmount;

  /**
   * 最小其他费用
   */
  private java.math.BigDecimal otherAmountMin;

  /**
   * 最大其他费用
   */
  private java.math.BigDecimal otherAmountMax;

  /**
   * 其他费用 比较(eq)
   */
  private java.math.BigDecimal otherAmountEq;
  /**
   * 其他费用 比较(neq)
   */
  private java.math.BigDecimal otherAmountNeq;
  /**
   * 其他费用 比较(gt)
   */
  private java.math.BigDecimal otherAmountGt;
  /**
   * 其他费用 比较(gte)
   */
  private java.math.BigDecimal otherAmountGte;
  /**
   * 其他费用 比较(lt)
   */
  private java.math.BigDecimal otherAmountLt;
  /**
   * 其他费用 比较(lte)
   */
  private java.math.BigDecimal otherAmountLte;
  /**
   * 其他费用 比较(contains)
   */
  private java.math.BigDecimal otherAmountContains;
  /**
   * 其他费用 比较(notcontains)
   */
  private java.math.BigDecimal otherAmountNotcontains;
  /**
   * 其他费用 比较(startswith)
   */
  private java.math.BigDecimal otherAmountStartswith;
  /**
   * 其他费用 比较(endswith)
   */
  private java.math.BigDecimal otherAmountEndswith;
  /**
   * 其他费用 比较(isnull)
   */
  private Boolean otherAmountIsnull;
  /**
   * 其他费用 比较(isnotnull)
   */
  private Boolean otherAmountIsnotnull;

  /**
   * 毛利润
   */
  private java.math.BigDecimal profit;

  /**
   * 最小毛利润
   */
  private java.math.BigDecimal profitMin;

  /**
   * 最大毛利润
   */
  private java.math.BigDecimal profitMax;

  /**
   * 毛利润 比较(eq)
   */
  private java.math.BigDecimal profitEq;
  /**
   * 毛利润 比较(neq)
   */
  private java.math.BigDecimal profitNeq;
  /**
   * 毛利润 比较(gt)
   */
  private java.math.BigDecimal profitGt;
  /**
   * 毛利润 比较(gte)
   */
  private java.math.BigDecimal profitGte;
  /**
   * 毛利润 比较(lt)
   */
  private java.math.BigDecimal profitLt;
  /**
   * 毛利润 比较(lte)
   */
  private java.math.BigDecimal profitLte;
  /**
   * 毛利润 比较(contains)
   */
  private java.math.BigDecimal profitContains;
  /**
   * 毛利润 比较(notcontains)
   */
  private java.math.BigDecimal profitNotcontains;
  /**
   * 毛利润 比较(startswith)
   */
  private java.math.BigDecimal profitStartswith;
  /**
   * 毛利润 比较(endswith)
   */
  private java.math.BigDecimal profitEndswith;
  /**
   * 毛利润 比较(isnull)
   */
  private Boolean profitIsnull;
  /**
   * 毛利润 比较(isnotnull)
   */
  private Boolean profitIsnotnull;

  /**
   * 商品支付金额（删除）
   */
  private java.math.BigDecimal itemPriceAmount;

  /**
   * 最小商品支付金额（删除）
   */
  private java.math.BigDecimal itemPriceAmountMin;

  /**
   * 最大商品支付金额（删除）
   */
  private java.math.BigDecimal itemPriceAmountMax;

  /**
   * 商品支付金额（删除） 比较(eq)
   */
  private java.math.BigDecimal itemPriceAmountEq;
  /**
   * 商品支付金额（删除） 比较(neq)
   */
  private java.math.BigDecimal itemPriceAmountNeq;
  /**
   * 商品支付金额（删除） 比较(gt)
   */
  private java.math.BigDecimal itemPriceAmountGt;
  /**
   * 商品支付金额（删除） 比较(gte)
   */
  private java.math.BigDecimal itemPriceAmountGte;
  /**
   * 商品支付金额（删除） 比较(lt)
   */
  private java.math.BigDecimal itemPriceAmountLt;
  /**
   * 商品支付金额（删除） 比较(lte)
   */
  private java.math.BigDecimal itemPriceAmountLte;
  /**
   * 商品支付金额（删除） 比较(contains)
   */
  private java.math.BigDecimal itemPriceAmountContains;
  /**
   * 商品支付金额（删除） 比较(notcontains)
   */
  private java.math.BigDecimal itemPriceAmountNotcontains;
  /**
   * 商品支付金额（删除） 比较(startswith)
   */
  private java.math.BigDecimal itemPriceAmountStartswith;
  /**
   * 商品支付金额（删除） 比较(endswith)
   */
  private java.math.BigDecimal itemPriceAmountEndswith;
  /**
   * 商品支付金额（删除） 比较(isnull)
   */
  private Boolean itemPriceAmountIsnull;
  /**
   * 商品支付金额（删除） 比较(isnotnull)
   */
  private Boolean itemPriceAmountIsnotnull;

  /**
   * 商品税（删除）
   */
  private java.math.BigDecimal itemTaxAmount;

  /**
   * 最小商品税（删除）
   */
  private java.math.BigDecimal itemTaxAmountMin;

  /**
   * 最大商品税（删除）
   */
  private java.math.BigDecimal itemTaxAmountMax;

  /**
   * 商品税（删除） 比较(eq)
   */
  private java.math.BigDecimal itemTaxAmountEq;
  /**
   * 商品税（删除） 比较(neq)
   */
  private java.math.BigDecimal itemTaxAmountNeq;
  /**
   * 商品税（删除） 比较(gt)
   */
  private java.math.BigDecimal itemTaxAmountGt;
  /**
   * 商品税（删除） 比较(gte)
   */
  private java.math.BigDecimal itemTaxAmountGte;
  /**
   * 商品税（删除） 比较(lt)
   */
  private java.math.BigDecimal itemTaxAmountLt;
  /**
   * 商品税（删除） 比较(lte)
   */
  private java.math.BigDecimal itemTaxAmountLte;
  /**
   * 商品税（删除） 比较(contains)
   */
  private java.math.BigDecimal itemTaxAmountContains;
  /**
   * 商品税（删除） 比较(notcontains)
   */
  private java.math.BigDecimal itemTaxAmountNotcontains;
  /**
   * 商品税（删除） 比较(startswith)
   */
  private java.math.BigDecimal itemTaxAmountStartswith;
  /**
   * 商品税（删除） 比较(endswith)
   */
  private java.math.BigDecimal itemTaxAmountEndswith;
  /**
   * 商品税（删除） 比较(isnull)
   */
  private Boolean itemTaxAmountIsnull;
  /**
   * 商品税（删除） 比较(isnotnull)
   */
  private Boolean itemTaxAmountIsnotnull;

  /**
   * 商品运费
   */
  private java.math.BigDecimal shippingPriceAmount;

  /**
   * 最小商品运费
   */
  private java.math.BigDecimal shippingPriceAmountMin;

  /**
   * 最大商品运费
   */
  private java.math.BigDecimal shippingPriceAmountMax;

  /**
   * 商品运费 比较(eq)
   */
  private java.math.BigDecimal shippingPriceAmountEq;
  /**
   * 商品运费 比较(neq)
   */
  private java.math.BigDecimal shippingPriceAmountNeq;
  /**
   * 商品运费 比较(gt)
   */
  private java.math.BigDecimal shippingPriceAmountGt;
  /**
   * 商品运费 比较(gte)
   */
  private java.math.BigDecimal shippingPriceAmountGte;
  /**
   * 商品运费 比较(lt)
   */
  private java.math.BigDecimal shippingPriceAmountLt;
  /**
   * 商品运费 比较(lte)
   */
  private java.math.BigDecimal shippingPriceAmountLte;
  /**
   * 商品运费 比较(contains)
   */
  private java.math.BigDecimal shippingPriceAmountContains;
  /**
   * 商品运费 比较(notcontains)
   */
  private java.math.BigDecimal shippingPriceAmountNotcontains;
  /**
   * 商品运费 比较(startswith)
   */
  private java.math.BigDecimal shippingPriceAmountStartswith;
  /**
   * 商品运费 比较(endswith)
   */
  private java.math.BigDecimal shippingPriceAmountEndswith;
  /**
   * 商品运费 比较(isnull)
   */
  private Boolean shippingPriceAmountIsnull;
  /**
   * 商品运费 比较(isnotnull)
   */
  private Boolean shippingPriceAmountIsnotnull;

  /**
   * 商品运费税
   */
  private java.math.BigDecimal shippingTaxAmount;

  /**
   * 最小商品运费税
   */
  private java.math.BigDecimal shippingTaxAmountMin;

  /**
   * 最大商品运费税
   */
  private java.math.BigDecimal shippingTaxAmountMax;

  /**
   * 商品运费税 比较(eq)
   */
  private java.math.BigDecimal shippingTaxAmountEq;
  /**
   * 商品运费税 比较(neq)
   */
  private java.math.BigDecimal shippingTaxAmountNeq;
  /**
   * 商品运费税 比较(gt)
   */
  private java.math.BigDecimal shippingTaxAmountGt;
  /**
   * 商品运费税 比较(gte)
   */
  private java.math.BigDecimal shippingTaxAmountGte;
  /**
   * 商品运费税 比较(lt)
   */
  private java.math.BigDecimal shippingTaxAmountLt;
  /**
   * 商品运费税 比较(lte)
   */
  private java.math.BigDecimal shippingTaxAmountLte;
  /**
   * 商品运费税 比较(contains)
   */
  private java.math.BigDecimal shippingTaxAmountContains;
  /**
   * 商品运费税 比较(notcontains)
   */
  private java.math.BigDecimal shippingTaxAmountNotcontains;
  /**
   * 商品运费税 比较(startswith)
   */
  private java.math.BigDecimal shippingTaxAmountStartswith;
  /**
   * 商品运费税 比较(endswith)
   */
  private java.math.BigDecimal shippingTaxAmountEndswith;
  /**
   * 商品运费税 比较(isnull)
   */
  private Boolean shippingTaxAmountIsnull;
  /**
   * 商品运费税 比较(isnotnull)
   */
  private Boolean shippingTaxAmountIsnotnull;

  /**
   * 礼品包装费
   */
  private java.math.BigDecimal giftWrapPriceAmount;

  /**
   * 最小礼品包装费
   */
  private java.math.BigDecimal giftWrapPriceAmountMin;

  /**
   * 最大礼品包装费
   */
  private java.math.BigDecimal giftWrapPriceAmountMax;

  /**
   * 礼品包装费 比较(eq)
   */
  private java.math.BigDecimal giftWrapPriceAmountEq;
  /**
   * 礼品包装费 比较(neq)
   */
  private java.math.BigDecimal giftWrapPriceAmountNeq;
  /**
   * 礼品包装费 比较(gt)
   */
  private java.math.BigDecimal giftWrapPriceAmountGt;
  /**
   * 礼品包装费 比较(gte)
   */
  private java.math.BigDecimal giftWrapPriceAmountGte;
  /**
   * 礼品包装费 比较(lt)
   */
  private java.math.BigDecimal giftWrapPriceAmountLt;
  /**
   * 礼品包装费 比较(lte)
   */
  private java.math.BigDecimal giftWrapPriceAmountLte;
  /**
   * 礼品包装费 比较(contains)
   */
  private java.math.BigDecimal giftWrapPriceAmountContains;
  /**
   * 礼品包装费 比较(notcontains)
   */
  private java.math.BigDecimal giftWrapPriceAmountNotcontains;
  /**
   * 礼品包装费 比较(startswith)
   */
  private java.math.BigDecimal giftWrapPriceAmountStartswith;
  /**
   * 礼品包装费 比较(endswith)
   */
  private java.math.BigDecimal giftWrapPriceAmountEndswith;
  /**
   * 礼品包装费 比较(isnull)
   */
  private Boolean giftWrapPriceAmountIsnull;
  /**
   * 礼品包装费 比较(isnotnull)
   */
  private Boolean giftWrapPriceAmountIsnotnull;

  /**
   * 礼品包装税
   */
  private java.math.BigDecimal giftWrapTaxAmount;

  /**
   * 最小礼品包装税
   */
  private java.math.BigDecimal giftWrapTaxAmountMin;

  /**
   * 最大礼品包装税
   */
  private java.math.BigDecimal giftWrapTaxAmountMax;

  /**
   * 礼品包装税 比较(eq)
   */
  private java.math.BigDecimal giftWrapTaxAmountEq;
  /**
   * 礼品包装税 比较(neq)
   */
  private java.math.BigDecimal giftWrapTaxAmountNeq;
  /**
   * 礼品包装税 比较(gt)
   */
  private java.math.BigDecimal giftWrapTaxAmountGt;
  /**
   * 礼品包装税 比较(gte)
   */
  private java.math.BigDecimal giftWrapTaxAmountGte;
  /**
   * 礼品包装税 比较(lt)
   */
  private java.math.BigDecimal giftWrapTaxAmountLt;
  /**
   * 礼品包装税 比较(lte)
   */
  private java.math.BigDecimal giftWrapTaxAmountLte;
  /**
   * 礼品包装税 比较(contains)
   */
  private java.math.BigDecimal giftWrapTaxAmountContains;
  /**
   * 礼品包装税 比较(notcontains)
   */
  private java.math.BigDecimal giftWrapTaxAmountNotcontains;
  /**
   * 礼品包装税 比较(startswith)
   */
  private java.math.BigDecimal giftWrapTaxAmountStartswith;
  /**
   * 礼品包装税 比较(endswith)
   */
  private java.math.BigDecimal giftWrapTaxAmountEndswith;
  /**
   * 礼品包装税 比较(isnull)
   */
  private Boolean giftWrapTaxAmountIsnull;
  /**
   * 礼品包装税 比较(isnotnull)
   */
  private Boolean giftWrapTaxAmountIsnotnull;

  /**
   * 配送折扣
   */
  private java.math.BigDecimal shippingDiscountAmount;

  /**
   * 最小配送折扣
   */
  private java.math.BigDecimal shippingDiscountAmountMin;

  /**
   * 最大配送折扣
   */
  private java.math.BigDecimal shippingDiscountAmountMax;

  /**
   * 配送折扣 比较(eq)
   */
  private java.math.BigDecimal shippingDiscountAmountEq;
  /**
   * 配送折扣 比较(neq)
   */
  private java.math.BigDecimal shippingDiscountAmountNeq;
  /**
   * 配送折扣 比较(gt)
   */
  private java.math.BigDecimal shippingDiscountAmountGt;
  /**
   * 配送折扣 比较(gte)
   */
  private java.math.BigDecimal shippingDiscountAmountGte;
  /**
   * 配送折扣 比较(lt)
   */
  private java.math.BigDecimal shippingDiscountAmountLt;
  /**
   * 配送折扣 比较(lte)
   */
  private java.math.BigDecimal shippingDiscountAmountLte;
  /**
   * 配送折扣 比较(contains)
   */
  private java.math.BigDecimal shippingDiscountAmountContains;
  /**
   * 配送折扣 比较(notcontains)
   */
  private java.math.BigDecimal shippingDiscountAmountNotcontains;
  /**
   * 配送折扣 比较(startswith)
   */
  private java.math.BigDecimal shippingDiscountAmountStartswith;
  /**
   * 配送折扣 比较(endswith)
   */
  private java.math.BigDecimal shippingDiscountAmountEndswith;
  /**
   * 配送折扣 比较(isnull)
   */
  private Boolean shippingDiscountAmountIsnull;
  /**
   * 配送折扣 比较(isnotnull)
   */
  private Boolean shippingDiscountAmountIsnotnull;

  /**
   * COD服务费用
   */
  private java.math.BigDecimal codFeeAmount;

  /**
   * 最小COD服务费用
   */
  private java.math.BigDecimal codFeeAmountMin;

  /**
   * 最大COD服务费用
   */
  private java.math.BigDecimal codFeeAmountMax;

  /**
   * COD服务费用 比较(eq)
   */
  private java.math.BigDecimal codFeeAmountEq;
  /**
   * COD服务费用 比较(neq)
   */
  private java.math.BigDecimal codFeeAmountNeq;
  /**
   * COD服务费用 比较(gt)
   */
  private java.math.BigDecimal codFeeAmountGt;
  /**
   * COD服务费用 比较(gte)
   */
  private java.math.BigDecimal codFeeAmountGte;
  /**
   * COD服务费用 比较(lt)
   */
  private java.math.BigDecimal codFeeAmountLt;
  /**
   * COD服务费用 比较(lte)
   */
  private java.math.BigDecimal codFeeAmountLte;
  /**
   * COD服务费用 比较(contains)
   */
  private java.math.BigDecimal codFeeAmountContains;
  /**
   * COD服务费用 比较(notcontains)
   */
  private java.math.BigDecimal codFeeAmountNotcontains;
  /**
   * COD服务费用 比较(startswith)
   */
  private java.math.BigDecimal codFeeAmountStartswith;
  /**
   * COD服务费用 比较(endswith)
   */
  private java.math.BigDecimal codFeeAmountEndswith;
  /**
   * COD服务费用 比较(isnull)
   */
  private Boolean codFeeAmountIsnull;
  /**
   * COD服务费用 比较(isnotnull)
   */
  private Boolean codFeeAmountIsnotnull;

  /**
   * 配送折扣税
   */
  private java.math.BigDecimal shippingDiscountTaxAmount;

  /**
   * 最小配送折扣税
   */
  private java.math.BigDecimal shippingDiscountTaxAmountMin;

  /**
   * 最大配送折扣税
   */
  private java.math.BigDecimal shippingDiscountTaxAmountMax;

  /**
   * 配送折扣税 比较(eq)
   */
  private java.math.BigDecimal shippingDiscountTaxAmountEq;
  /**
   * 配送折扣税 比较(neq)
   */
  private java.math.BigDecimal shippingDiscountTaxAmountNeq;
  /**
   * 配送折扣税 比较(gt)
   */
  private java.math.BigDecimal shippingDiscountTaxAmountGt;
  /**
   * 配送折扣税 比较(gte)
   */
  private java.math.BigDecimal shippingDiscountTaxAmountGte;
  /**
   * 配送折扣税 比较(lt)
   */
  private java.math.BigDecimal shippingDiscountTaxAmountLt;
  /**
   * 配送折扣税 比较(lte)
   */
  private java.math.BigDecimal shippingDiscountTaxAmountLte;
  /**
   * 配送折扣税 比较(contains)
   */
  private java.math.BigDecimal shippingDiscountTaxAmountContains;
  /**
   * 配送折扣税 比较(notcontains)
   */
  private java.math.BigDecimal shippingDiscountTaxAmountNotcontains;
  /**
   * 配送折扣税 比较(startswith)
   */
  private java.math.BigDecimal shippingDiscountTaxAmountStartswith;
  /**
   * 配送折扣税 比较(endswith)
   */
  private java.math.BigDecimal shippingDiscountTaxAmountEndswith;
  /**
   * 配送折扣税 比较(isnull)
   */
  private Boolean shippingDiscountTaxAmountIsnull;
  /**
   * 配送折扣税 比较(isnotnull)
   */
  private Boolean shippingDiscountTaxAmountIsnotnull;

  /**
   * 商品促销折扣
   */
  private java.math.BigDecimal promotionDiscountAmount;

  /**
   * 最小商品促销折扣
   */
  private java.math.BigDecimal promotionDiscountAmountMin;

  /**
   * 最大商品促销折扣
   */
  private java.math.BigDecimal promotionDiscountAmountMax;

  /**
   * 商品促销折扣 比较(eq)
   */
  private java.math.BigDecimal promotionDiscountAmountEq;
  /**
   * 商品促销折扣 比较(neq)
   */
  private java.math.BigDecimal promotionDiscountAmountNeq;
  /**
   * 商品促销折扣 比较(gt)
   */
  private java.math.BigDecimal promotionDiscountAmountGt;
  /**
   * 商品促销折扣 比较(gte)
   */
  private java.math.BigDecimal promotionDiscountAmountGte;
  /**
   * 商品促销折扣 比较(lt)
   */
  private java.math.BigDecimal promotionDiscountAmountLt;
  /**
   * 商品促销折扣 比较(lte)
   */
  private java.math.BigDecimal promotionDiscountAmountLte;
  /**
   * 商品促销折扣 比较(contains)
   */
  private java.math.BigDecimal promotionDiscountAmountContains;
  /**
   * 商品促销折扣 比较(notcontains)
   */
  private java.math.BigDecimal promotionDiscountAmountNotcontains;
  /**
   * 商品促销折扣 比较(startswith)
   */
  private java.math.BigDecimal promotionDiscountAmountStartswith;
  /**
   * 商品促销折扣 比较(endswith)
   */
  private java.math.BigDecimal promotionDiscountAmountEndswith;
  /**
   * 商品促销折扣 比较(isnull)
   */
  private Boolean promotionDiscountAmountIsnull;
  /**
   * 商品促销折扣 比较(isnotnull)
   */
  private Boolean promotionDiscountAmountIsnotnull;

  /**
   * 商品促销折扣税
   */
  private java.math.BigDecimal promotionDiscountTaxAmount;

  /**
   * 最小商品促销折扣税
   */
  private java.math.BigDecimal promotionDiscountTaxAmountMin;

  /**
   * 最大商品促销折扣税
   */
  private java.math.BigDecimal promotionDiscountTaxAmountMax;

  /**
   * 商品促销折扣税 比较(eq)
   */
  private java.math.BigDecimal promotionDiscountTaxAmountEq;
  /**
   * 商品促销折扣税 比较(neq)
   */
  private java.math.BigDecimal promotionDiscountTaxAmountNeq;
  /**
   * 商品促销折扣税 比较(gt)
   */
  private java.math.BigDecimal promotionDiscountTaxAmountGt;
  /**
   * 商品促销折扣税 比较(gte)
   */
  private java.math.BigDecimal promotionDiscountTaxAmountGte;
  /**
   * 商品促销折扣税 比较(lt)
   */
  private java.math.BigDecimal promotionDiscountTaxAmountLt;
  /**
   * 商品促销折扣税 比较(lte)
   */
  private java.math.BigDecimal promotionDiscountTaxAmountLte;
  /**
   * 商品促销折扣税 比较(contains)
   */
  private java.math.BigDecimal promotionDiscountTaxAmountContains;
  /**
   * 商品促销折扣税 比较(notcontains)
   */
  private java.math.BigDecimal promotionDiscountTaxAmountNotcontains;
  /**
   * 商品促销折扣税 比较(startswith)
   */
  private java.math.BigDecimal promotionDiscountTaxAmountStartswith;
  /**
   * 商品促销折扣税 比较(endswith)
   */
  private java.math.BigDecimal promotionDiscountTaxAmountEndswith;
  /**
   * 商品促销折扣税 比较(isnull)
   */
  private Boolean promotionDiscountTaxAmountIsnull;
  /**
   * 商品促销折扣税 比较(isnotnull)
   */
  private Boolean promotionDiscountTaxAmountIsnotnull;

  /**
   * COD服务费用折扣
   */
  private java.math.BigDecimal codFeeDiscountAmount;

  /**
   * 最小COD服务费用折扣
   */
  private java.math.BigDecimal codFeeDiscountAmountMin;

  /**
   * 最大COD服务费用折扣
   */
  private java.math.BigDecimal codFeeDiscountAmountMax;

  /**
   * COD服务费用折扣 比较(eq)
   */
  private java.math.BigDecimal codFeeDiscountAmountEq;
  /**
   * COD服务费用折扣 比较(neq)
   */
  private java.math.BigDecimal codFeeDiscountAmountNeq;
  /**
   * COD服务费用折扣 比较(gt)
   */
  private java.math.BigDecimal codFeeDiscountAmountGt;
  /**
   * COD服务费用折扣 比较(gte)
   */
  private java.math.BigDecimal codFeeDiscountAmountGte;
  /**
   * COD服务费用折扣 比较(lt)
   */
  private java.math.BigDecimal codFeeDiscountAmountLt;
  /**
   * COD服务费用折扣 比较(lte)
   */
  private java.math.BigDecimal codFeeDiscountAmountLte;
  /**
   * COD服务费用折扣 比较(contains)
   */
  private java.math.BigDecimal codFeeDiscountAmountContains;
  /**
   * COD服务费用折扣 比较(notcontains)
   */
  private java.math.BigDecimal codFeeDiscountAmountNotcontains;
  /**
   * COD服务费用折扣 比较(startswith)
   */
  private java.math.BigDecimal codFeeDiscountAmountStartswith;
  /**
   * COD服务费用折扣 比较(endswith)
   */
  private java.math.BigDecimal codFeeDiscountAmountEndswith;
  /**
   * COD服务费用折扣 比较(isnull)
   */
  private Boolean codFeeDiscountAmountIsnull;
  /**
   * COD服务费用折扣 比较(isnotnull)
   */
  private Boolean codFeeDiscountAmountIsnotnull;

  /**
   * 礼品信息（买家提供）(模糊搜索)
   */
  private String giftMessageText;

  /**
   * 礼品信息（买家提供） 比较(eq)
   */
  private String giftMessageTextEq;
  /**
   * 礼品信息（买家提供） 比较(neq)
   */
  private String giftMessageTextNeq;
  /**
   * 礼品信息（买家提供） 比较(gt)
   */
  private String giftMessageTextGt;
  /**
   * 礼品信息（买家提供） 比较(gte)
   */
  private String giftMessageTextGte;
  /**
   * 礼品信息（买家提供） 比较(lt)
   */
  private String giftMessageTextLt;
  /**
   * 礼品信息（买家提供） 比较(lte)
   */
  private String giftMessageTextLte;
  /**
   * 礼品信息（买家提供） 比较(contains)
   */
  private String giftMessageTextContains;
  /**
   * 礼品信息（买家提供） 比较(notcontains)
   */
  private String giftMessageTextNotcontains;
  /**
   * 礼品信息（买家提供） 比较(startswith)
   */
  private String giftMessageTextStartswith;
  /**
   * 礼品信息（买家提供） 比较(endswith)
   */
  private String giftMessageTextEndswith;
  /**
   * 礼品信息（买家提供） 比较(isnull)
   */
  private Boolean giftMessageTextIsnull;
  /**
   * 礼品信息（买家提供） 比较(isnotnull)
   */
  private Boolean giftMessageTextIsnotnull;

  /**
   * 礼品信息（买家提供）(精确搜索)
   */
  private List<String> giftMessageTextInList;

  /**
   * 礼品包装级别（买家提供）(模糊搜索)
   */
  private String giftWrapLevel;

  /**
   * 礼品包装级别（买家提供） 比较(eq)
   */
  private String giftWrapLevelEq;
  /**
   * 礼品包装级别（买家提供） 比较(neq)
   */
  private String giftWrapLevelNeq;
  /**
   * 礼品包装级别（买家提供） 比较(gt)
   */
  private String giftWrapLevelGt;
  /**
   * 礼品包装级别（买家提供） 比较(gte)
   */
  private String giftWrapLevelGte;
  /**
   * 礼品包装级别（买家提供） 比较(lt)
   */
  private String giftWrapLevelLt;
  /**
   * 礼品包装级别（买家提供） 比较(lte)
   */
  private String giftWrapLevelLte;
  /**
   * 礼品包装级别（买家提供） 比较(contains)
   */
  private String giftWrapLevelContains;
  /**
   * 礼品包装级别（买家提供） 比较(notcontains)
   */
  private String giftWrapLevelNotcontains;
  /**
   * 礼品包装级别（买家提供） 比较(startswith)
   */
  private String giftWrapLevelStartswith;
  /**
   * 礼品包装级别（买家提供） 比较(endswith)
   */
  private String giftWrapLevelEndswith;
  /**
   * 礼品包装级别（买家提供） 比较(isnull)
   */
  private Boolean giftWrapLevelIsnull;
  /**
   * 礼品包装级别（买家提供） 比较(isnotnull)
   */
  private Boolean giftWrapLevelIsnotnull;

  /**
   * 礼品包装级别（买家提供）(精确搜索)
   */
  private List<String> giftWrapLevelInList;

  /**
   * 商品状况说明（卖家提供）(模糊搜索)
   */
  private String conditionNote;

  /**
   * 商品状况说明（卖家提供） 比较(eq)
   */
  private String conditionNoteEq;
  /**
   * 商品状况说明（卖家提供） 比较(neq)
   */
  private String conditionNoteNeq;
  /**
   * 商品状况说明（卖家提供） 比较(gt)
   */
  private String conditionNoteGt;
  /**
   * 商品状况说明（卖家提供） 比较(gte)
   */
  private String conditionNoteGte;
  /**
   * 商品状况说明（卖家提供） 比较(lt)
   */
  private String conditionNoteLt;
  /**
   * 商品状况说明（卖家提供） 比较(lte)
   */
  private String conditionNoteLte;
  /**
   * 商品状况说明（卖家提供） 比较(contains)
   */
  private String conditionNoteContains;
  /**
   * 商品状况说明（卖家提供） 比较(notcontains)
   */
  private String conditionNoteNotcontains;
  /**
   * 商品状况说明（卖家提供） 比较(startswith)
   */
  private String conditionNoteStartswith;
  /**
   * 商品状况说明（卖家提供） 比较(endswith)
   */
  private String conditionNoteEndswith;
  /**
   * 商品状况说明（卖家提供） 比较(isnull)
   */
  private Boolean conditionNoteIsnull;
  /**
   * 商品状况说明（卖家提供） 比较(isnotnull)
   */
  private Boolean conditionNoteIsnotnull;

  /**
   * 商品状况说明（卖家提供）(精确搜索)
   */
  private List<String> conditionNoteInList;

  /**
   * 商品状况（卖家提供）(模糊搜索)
   */
  private String conditionId;

  /**
   * 商品状况（卖家提供） 比较(eq)
   */
  private String conditionIdEq;
  /**
   * 商品状况（卖家提供） 比较(neq)
   */
  private String conditionIdNeq;
  /**
   * 商品状况（卖家提供） 比较(gt)
   */
  private String conditionIdGt;
  /**
   * 商品状况（卖家提供） 比较(gte)
   */
  private String conditionIdGte;
  /**
   * 商品状况（卖家提供） 比较(lt)
   */
  private String conditionIdLt;
  /**
   * 商品状况（卖家提供） 比较(lte)
   */
  private String conditionIdLte;
  /**
   * 商品状况（卖家提供） 比较(contains)
   */
  private String conditionIdContains;
  /**
   * 商品状况（卖家提供） 比较(notcontains)
   */
  private String conditionIdNotcontains;
  /**
   * 商品状况（卖家提供） 比较(startswith)
   */
  private String conditionIdStartswith;
  /**
   * 商品状况（卖家提供） 比较(endswith)
   */
  private String conditionIdEndswith;
  /**
   * 商品状况（卖家提供） 比较(isnull)
   */
  private Boolean conditionIdIsnull;
  /**
   * 商品状况（卖家提供） 比较(isnotnull)
   */
  private Boolean conditionIdIsnotnull;

  /**
   * 商品状况（卖家提供）(精确搜索)
   */
  private List<String> conditionIdInList;

  /**
   * 商品子状况（卖家提供）(模糊搜索)
   */
  private String conditionSubtypeId;

  /**
   * 商品子状况（卖家提供） 比较(eq)
   */
  private String conditionSubtypeIdEq;
  /**
   * 商品子状况（卖家提供） 比较(neq)
   */
  private String conditionSubtypeIdNeq;
  /**
   * 商品子状况（卖家提供） 比较(gt)
   */
  private String conditionSubtypeIdGt;
  /**
   * 商品子状况（卖家提供） 比较(gte)
   */
  private String conditionSubtypeIdGte;
  /**
   * 商品子状况（卖家提供） 比较(lt)
   */
  private String conditionSubtypeIdLt;
  /**
   * 商品子状况（卖家提供） 比较(lte)
   */
  private String conditionSubtypeIdLte;
  /**
   * 商品子状况（卖家提供） 比较(contains)
   */
  private String conditionSubtypeIdContains;
  /**
   * 商品子状况（卖家提供） 比较(notcontains)
   */
  private String conditionSubtypeIdNotcontains;
  /**
   * 商品子状况（卖家提供） 比较(startswith)
   */
  private String conditionSubtypeIdStartswith;
  /**
   * 商品子状况（卖家提供） 比较(endswith)
   */
  private String conditionSubtypeIdEndswith;
  /**
   * 商品子状况（卖家提供） 比较(isnull)
   */
  private Boolean conditionSubtypeIdIsnull;
  /**
   * 商品子状况（卖家提供） 比较(isnotnull)
   */
  private Boolean conditionSubtypeIdIsnotnull;

  /**
   * 商品子状况（卖家提供）(精确搜索)
   */
  private List<String> conditionSubtypeIdInList;

  /**
   * 最早计划交货开始日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date scheduledDeliveryStartDateStart;

  /**
   * 最晚计划交货开始日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date scheduledDeliveryStartDateEnd;

  /**
   * 计划交货开始日期 比较(eq)
   */
  private Date scheduledDeliveryStartDateEq;
  /**
   * 计划交货开始日期 比较(neq)
   */
  private Date scheduledDeliveryStartDateNeq;
  /**
   * 计划交货开始日期 比较(gt)
   */
  private Date scheduledDeliveryStartDateGt;
  /**
   * 计划交货开始日期 比较(gte)
   */
  private Date scheduledDeliveryStartDateGte;
  /**
   * 计划交货开始日期 比较(lt)
   */
  private Date scheduledDeliveryStartDateLt;
  /**
   * 计划交货开始日期 比较(lte)
   */
  private Date scheduledDeliveryStartDateLte;
  /**
   * 计划交货开始日期 比较(contains)
   */
  private Date scheduledDeliveryStartDateContains;
  /**
   * 计划交货开始日期 比较(notcontains)
   */
  private Date scheduledDeliveryStartDateNotcontains;
  /**
   * 计划交货开始日期 比较(startswith)
   */
  private Date scheduledDeliveryStartDateStartswith;
  /**
   * 计划交货开始日期 比较(endswith)
   */
  private Date scheduledDeliveryStartDateEndswith;
  /**
   * 计划交货开始日期 比较(isnull)
   */
  private Boolean scheduledDeliveryStartDateIsnull;
  /**
   * 计划交货开始日期 比较(isnotnull)
   */
  private Boolean scheduledDeliveryStartDateIsnotnull;

  /**
   * 最早计划交货结束日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date scheduledDeliveryEndDateStart;

  /**
   * 最晚计划交货结束日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date scheduledDeliveryEndDateEnd;

  /**
   * 计划交货结束日期 比较(eq)
   */
  private Date scheduledDeliveryEndDateEq;
  /**
   * 计划交货结束日期 比较(neq)
   */
  private Date scheduledDeliveryEndDateNeq;
  /**
   * 计划交货结束日期 比较(gt)
   */
  private Date scheduledDeliveryEndDateGt;
  /**
   * 计划交货结束日期 比较(gte)
   */
  private Date scheduledDeliveryEndDateGte;
  /**
   * 计划交货结束日期 比较(lt)
   */
  private Date scheduledDeliveryEndDateLt;
  /**
   * 计划交货结束日期 比较(lte)
   */
  private Date scheduledDeliveryEndDateLte;
  /**
   * 计划交货结束日期 比较(contains)
   */
  private Date scheduledDeliveryEndDateContains;
  /**
   * 计划交货结束日期 比较(notcontains)
   */
  private Date scheduledDeliveryEndDateNotcontains;
  /**
   * 计划交货结束日期 比较(startswith)
   */
  private Date scheduledDeliveryEndDateStartswith;
  /**
   * 计划交货结束日期 比较(endswith)
   */
  private Date scheduledDeliveryEndDateEndswith;
  /**
   * 计划交货结束日期 比较(isnull)
   */
  private Boolean scheduledDeliveryEndDateIsnull;
  /**
   * 计划交货结束日期 比较(isnotnull)
   */
  private Boolean scheduledDeliveryEndDateIsnotnull;

  /**
   * B2B价格(模糊搜索)
   */
  private String priceDesignation;

  /**
   * B2B价格 比较(eq)
   */
  private String priceDesignationEq;
  /**
   * B2B价格 比较(neq)
   */
  private String priceDesignationNeq;
  /**
   * B2B价格 比较(gt)
   */
  private String priceDesignationGt;
  /**
   * B2B价格 比较(gte)
   */
  private String priceDesignationGte;
  /**
   * B2B价格 比较(lt)
   */
  private String priceDesignationLt;
  /**
   * B2B价格 比较(lte)
   */
  private String priceDesignationLte;
  /**
   * B2B价格 比较(contains)
   */
  private String priceDesignationContains;
  /**
   * B2B价格 比较(notcontains)
   */
  private String priceDesignationNotcontains;
  /**
   * B2B价格 比较(startswith)
   */
  private String priceDesignationStartswith;
  /**
   * B2B价格 比较(endswith)
   */
  private String priceDesignationEndswith;
  /**
   * B2B价格 比较(isnull)
   */
  private Boolean priceDesignationIsnull;
  /**
   * B2B价格 比较(isnotnull)
   */
  private Boolean priceDesignationIsnotnull;

  /**
   * B2B价格(精确搜索)
   */
  private List<String> priceDesignationInList;

  /**
   * 其他费名称(模糊搜索)
   */
  private String feeName;

  /**
   * 其他费名称 比较(eq)
   */
  private String feeNameEq;
  /**
   * 其他费名称 比较(neq)
   */
  private String feeNameNeq;
  /**
   * 其他费名称 比较(gt)
   */
  private String feeNameGt;
  /**
   * 其他费名称 比较(gte)
   */
  private String feeNameGte;
  /**
   * 其他费名称 比较(lt)
   */
  private String feeNameLt;
  /**
   * 其他费名称 比较(lte)
   */
  private String feeNameLte;
  /**
   * 其他费名称 比较(contains)
   */
  private String feeNameContains;
  /**
   * 其他费名称 比较(notcontains)
   */
  private String feeNameNotcontains;
  /**
   * 其他费名称 比较(startswith)
   */
  private String feeNameStartswith;
  /**
   * 其他费名称 比较(endswith)
   */
  private String feeNameEndswith;
  /**
   * 其他费名称 比较(isnull)
   */
  private Boolean feeNameIsnull;
  /**
   * 其他费名称 比较(isnotnull)
   */
  private Boolean feeNameIsnotnull;

  /**
   * 其他费名称(精确搜索)
   */
  private List<String> feeNameInList;

  /**
   * 其他费币种(模糊搜索)
   */
  private String feeCurrency;

  /**
   * 其他费币种 比较(eq)
   */
  private String feeCurrencyEq;
  /**
   * 其他费币种 比较(neq)
   */
  private String feeCurrencyNeq;
  /**
   * 其他费币种 比较(gt)
   */
  private String feeCurrencyGt;
  /**
   * 其他费币种 比较(gte)
   */
  private String feeCurrencyGte;
  /**
   * 其他费币种 比较(lt)
   */
  private String feeCurrencyLt;
  /**
   * 其他费币种 比较(lte)
   */
  private String feeCurrencyLte;
  /**
   * 其他费币种 比较(contains)
   */
  private String feeCurrencyContains;
  /**
   * 其他费币种 比较(notcontains)
   */
  private String feeCurrencyNotcontains;
  /**
   * 其他费币种 比较(startswith)
   */
  private String feeCurrencyStartswith;
  /**
   * 其他费币种 比较(endswith)
   */
  private String feeCurrencyEndswith;
  /**
   * 其他费币种 比较(isnull)
   */
  private Boolean feeCurrencyIsnull;
  /**
   * 其他费币种 比较(isnotnull)
   */
  private Boolean feeCurrencyIsnotnull;

  /**
   * 其他费币种(精确搜索)
   */
  private List<String> feeCurrencyInList;

  /**
   * 其他费币种符号(模糊搜索)
   */
  private String feeIcon;

  /**
   * 其他费币种符号 比较(eq)
   */
  private String feeIconEq;
  /**
   * 其他费币种符号 比较(neq)
   */
  private String feeIconNeq;
  /**
   * 其他费币种符号 比较(gt)
   */
  private String feeIconGt;
  /**
   * 其他费币种符号 比较(gte)
   */
  private String feeIconGte;
  /**
   * 其他费币种符号 比较(lt)
   */
  private String feeIconLt;
  /**
   * 其他费币种符号 比较(lte)
   */
  private String feeIconLte;
  /**
   * 其他费币种符号 比较(contains)
   */
  private String feeIconContains;
  /**
   * 其他费币种符号 比较(notcontains)
   */
  private String feeIconNotcontains;
  /**
   * 其他费币种符号 比较(startswith)
   */
  private String feeIconStartswith;
  /**
   * 其他费币种符号 比较(endswith)
   */
  private String feeIconEndswith;
  /**
   * 其他费币种符号 比较(isnull)
   */
  private Boolean feeIconIsnull;
  /**
   * 其他费币种符号 比较(isnotnull)
   */
  private Boolean feeIconIsnotnull;

  /**
   * 其他费币种符号(精确搜索)
   */
  private List<String> feeIconInList;

  /**
   * 其他费金额
   */
  private java.math.BigDecimal feeCost;

  /**
   * 最小其他费金额
   */
  private java.math.BigDecimal feeCostMin;

  /**
   * 最大其他费金额
   */
  private java.math.BigDecimal feeCostMax;

  /**
   * 其他费金额 比较(eq)
   */
  private java.math.BigDecimal feeCostEq;
  /**
   * 其他费金额 比较(neq)
   */
  private java.math.BigDecimal feeCostNeq;
  /**
   * 其他费金额 比较(gt)
   */
  private java.math.BigDecimal feeCostGt;
  /**
   * 其他费金额 比较(gte)
   */
  private java.math.BigDecimal feeCostGte;
  /**
   * 其他费金额 比较(lt)
   */
  private java.math.BigDecimal feeCostLt;
  /**
   * 其他费金额 比较(lte)
   */
  private java.math.BigDecimal feeCostLte;
  /**
   * 其他费金额 比较(contains)
   */
  private java.math.BigDecimal feeCostContains;
  /**
   * 其他费金额 比较(notcontains)
   */
  private java.math.BigDecimal feeCostNotcontains;
  /**
   * 其他费金额 比较(startswith)
   */
  private java.math.BigDecimal feeCostStartswith;
  /**
   * 其他费金额 比较(endswith)
   */
  private java.math.BigDecimal feeCostEndswith;
  /**
   * 其他费金额 比较(isnull)
   */
  private Boolean feeCostIsnull;
  /**
   * 其他费金额 比较(isnotnull)
   */
  private Boolean feeCostIsnotnull;

  /**
   * 商品折扣
   */
  private java.math.BigDecimal itemDiscount;

  /**
   * 最小商品折扣
   */
  private java.math.BigDecimal itemDiscountMin;

  /**
   * 最大商品折扣
   */
  private java.math.BigDecimal itemDiscountMax;

  /**
   * 商品折扣 比较(eq)
   */
  private java.math.BigDecimal itemDiscountEq;
  /**
   * 商品折扣 比较(neq)
   */
  private java.math.BigDecimal itemDiscountNeq;
  /**
   * 商品折扣 比较(gt)
   */
  private java.math.BigDecimal itemDiscountGt;
  /**
   * 商品折扣 比较(gte)
   */
  private java.math.BigDecimal itemDiscountGte;
  /**
   * 商品折扣 比较(lt)
   */
  private java.math.BigDecimal itemDiscountLt;
  /**
   * 商品折扣 比较(lte)
   */
  private java.math.BigDecimal itemDiscountLte;
  /**
   * 商品折扣 比较(contains)
   */
  private java.math.BigDecimal itemDiscountContains;
  /**
   * 商品折扣 比较(notcontains)
   */
  private java.math.BigDecimal itemDiscountNotcontains;
  /**
   * 商品折扣 比较(startswith)
   */
  private java.math.BigDecimal itemDiscountStartswith;
  /**
   * 商品折扣 比较(endswith)
   */
  private java.math.BigDecimal itemDiscountEndswith;
  /**
   * 商品折扣 比较(isnull)
   */
  private Boolean itemDiscountIsnull;
  /**
   * 商品折扣 比较(isnotnull)
   */
  private Boolean itemDiscountIsnotnull;

  /**
   * 订单号(模糊搜索)
   */
  private String amazonOrderId;

  /**
   * 订单号 比较(eq)
   */
  private String amazonOrderIdEq;
  /**
   * 订单号 比较(neq)
   */
  private String amazonOrderIdNeq;
  /**
   * 订单号 比较(gt)
   */
  private String amazonOrderIdGt;
  /**
   * 订单号 比较(gte)
   */
  private String amazonOrderIdGte;
  /**
   * 订单号 比较(lt)
   */
  private String amazonOrderIdLt;
  /**
   * 订单号 比较(lte)
   */
  private String amazonOrderIdLte;
  /**
   * 订单号 比较(contains)
   */
  private String amazonOrderIdContains;
  /**
   * 订单号 比较(notcontains)
   */
  private String amazonOrderIdNotcontains;
  /**
   * 订单号 比较(startswith)
   */
  private String amazonOrderIdStartswith;
  /**
   * 订单号 比较(endswith)
   */
  private String amazonOrderIdEndswith;
  /**
   * 订单号 比较(isnull)
   */
  private Boolean amazonOrderIdIsnull;
  /**
   * 订单号 比较(isnotnull)
   */
  private Boolean amazonOrderIdIsnotnull;

  /**
   * 订单号(精确搜索)
   */
  private List<String> amazonOrderIdInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
